// 查询内容处理工具

/**
 * 获取预览内容，截取指定长度并添加省略号
 * @param {string} content 原始内容
 * @param {number} length 截取长度
 * @returns {string} 预览内容
 */
export function getContentPreview(content, length = 50) {
  if (!content) return ''
  if (content.length <= length) return content
  return content.substring(0, length) + '...'
}

/**
 * 从查询内容中提取关键词
 * @param {string} content 查询内容
 * @param {number} maxKeywords 最大关键词数量
 * @returns {Array<string>} 关键词数组
 */
export function extractKeywords(content, maxKeywords = 5) {
  if (!content) return []

  // 简单实现：去除停用词，拆分为单词，按出现频率排序
  // 在实际应用中，可以使用更复杂的NLP算法或调用服务
  const stopWords = [
    '的',
    '了',
    '和',
    '与',
    '在',
    '是',
    '有',
    '这',
    '那',
    '你',
    '我',
    '他',
    '她',
    '它',
    '们',
  ]

  // 处理中文和英文
  const words = content
    .toLowerCase()
    .replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, ' ') // 保留中文、英文、数字
    .split(/\s+/)
    .filter((word) => word && word.length > 1 && !stopWords.includes(word))

  // 统计词频
  const wordCount = {}
  words.forEach((word) => {
    wordCount[word] = (wordCount[word] || 0) + 1
  })

  // 按词频排序，取前N个
  return Object.entries(wordCount)
    .sort((a, b) => b[1] - a[1])
    .slice(0, maxKeywords)
    .map((item) => item[0])
}

/**
 * 计算查询的复杂度评分
 * @param {string} query 查询内容
 * @returns {number} 复杂度评分（1-10）
 */
export function calculateQueryComplexity(query) {
  if (!query) return 1

  let score = 1

  // 长度因素
  const length = query.length
  if (length > 200) score += 3
  else if (length > 100) score += 2
  else if (length > 50) score += 1

  // 特殊符号因素
  const symbolCount = (query.match(/[?!,.;:{}[\]()]/g) || []).length
  score += Math.min(symbolCount / 5, 2)

  // 数字因素
  const numberCount = (query.match(/\d+/g) || []).length
  score += Math.min(numberCount / 3, 2)

  // 词语多样性
  const uniqueWordCount = new Set(query.split(/\s+/)).size
  score += Math.min(uniqueWordCount / 10, 3)

  return Math.min(Math.round(score), 10)
}

/**
 * 格式化token数量，添加千位分隔符
 * @param {number} tokens token数量
 * @returns {string} 格式化后的字符串
 */
export function formatTokens(tokens) {
  return tokens ? tokens.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',') : '0'
}

/**
 * 根据token数量获取颜色等级
 * @param {number} tokens token数量
 * @returns {string} 颜色类型: success, warning, danger
 */
export function getTokenColorType(tokens) {
  if (!tokens) return 'info'
  if (tokens < 1000) return 'success'
  if (tokens < 3000) return 'warning'
  return 'danger'
}

/**
 * 根据回答长度获取颜色等级
 * @param {number} length 回答长度
 * @returns {string} 颜色类型: success, warning, danger
 */
export function getResponseLengthColorType(length) {
  if (!length) return 'info'
  if (length < 300) return 'warning' // 回答过短
  if (length < 3000) return 'success' // 适中长度
  return 'warning' // 过长
}

/**
 * 根据查询状态获取状态标签类型
 * @param {string} status 查询状态
 * @returns {string} 标签类型: success, warning, danger, info
 */
export function getStatusTagType(status) {
  const statusMap = {
    success: 'success',
    processing: 'info',
    waiting: 'info',
    failed: 'danger',
    timeout: 'warning',
  }
  return statusMap[status] || 'info'
}

/**
 * 根据查询状态获取状态文本
 * @param {string} status 查询状态
 * @returns {string} 状态文本
 */
export function getStatusText(status) {
  const statusMap = {
    success: '成功',
    processing: '处理中',
    waiting: '等待中',
    failed: '失败',
    timeout: '超时',
  }
  return statusMap[status] || status
}

/**
 * 格式化时间戳为易读格式
 * @param {number|string} timestamp 时间戳
 * @param {boolean} includeTime 是否包含时间
 * @returns {string} 格式化的时间
 */
export function formatTimestamp(timestamp, includeTime = true) {
  if (!timestamp) return '--'

  const date = new Date(timestamp)
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')

  if (!includeTime) {
    return `${year}-${month}-${day}`
  }

  const hours = String(date.getHours()).padStart(2, '0')
  const minutes = String(date.getMinutes()).padStart(2, '0')
  const seconds = String(date.getSeconds()).padStart(2, '0')

  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
}

/**
 * 格式化执行时间，转换为适当的单位（ms或s）
 * @param {number} time 执行时间（毫秒）
 * @returns {string} 格式化后的执行时间
 */
export function formatExecutionTime(time) {
  if (!time && time !== 0) return '--'

  if (time < 1000) {
    return `${time}ms`
  } else {
    return `${(time / 1000).toFixed(2)}s`
  }
}

/**
 * 从Markdown内容中提取表格数据
 * @param {string} markdown Markdown文本
 * @returns {Array<{headers: Array<string>, rows: Array<Array<string>>}>} 表格数据数组
 */
export function extractTablesFromMarkdown(markdown) {
  if (!markdown) return []

  const tables = []
  const tableRegex = /\|(.+)\|[\r\n]+\|([-:| ]+)\|[\r\n]+((?:\|.+\|[\r\n]+)+)/g
  let match

  while ((match = tableRegex.exec(markdown)) !== null) {
    const headerRow = match[1].trim()
    // 提取对齐信息，但当前版本未使用
    // const alignmentRow = match[2].trim()
    const dataRows = match[3].trim()

    // 解析表头
    const headers = headerRow
      .split('|')
      .map((h) => h.trim())
      .filter((h) => h)

    // 解析数据行
    const rows = dataRows
      .split('\n')
      .map((row) => {
        return row
          .split('|')
          .map((cell) => cell.trim())
          .filter((cell) => cell !== '')
      })
      .filter((row) => row.length > 0)

    tables.push({ headers, rows })
  }

  return tables
}

/**
 * 解析JSON字符串
 * @param {string} jsonString JSON字符串
 * @param {*} defaultValue 解析失败时的默认值
 * @returns {*} 解析结果
 */
export function parseJSON(jsonString, defaultValue = null) {
  try {
    return jsonString ? JSON.parse(jsonString) : defaultValue
  } catch (error) {
    console.error('JSON解析错误', error)
    return defaultValue
  }
}
